package com.ruoyi.psi.base.category.service;


import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.psi.base.category.domain.BaseCategory;
import com.ruoyi.psi.base.category.mapper.BaseCategoryMapper;
import com.ruoyi.utils.TreeSelect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 产品类别
 * 业务层处理
 * @author Drj 2021/6/28
 */
@Service
public class BaseCategoryImpl implements IBaseCategoryService {
    @Autowired
    private BaseCategoryMapper baseCategoryMapper;


    /**
     * 根据条件查询产品类别
     *
     * @param baseCategory 产品类别信息
     * @return 产品类别集合
     */
    @Override
    public List<BaseCategory> selectBaseCategoryList(BaseCategory baseCategory) {
        return baseCategoryMapper.selectBaseCategoryList(baseCategory);
    }

    /**
     * 根据id查询产品类别
     *
     * @param baseCategoryId 产品类别编号
     * @return 产品类别
     */
    @Override
    public BaseCategory selectBaseCategoryById(String baseCategoryId) {
        return baseCategoryMapper.selectBaseCategoryById(baseCategoryId);
    }

    /**
     * 新增产品类别
     *
     * @param baseCategory 产品类别信息
     * @return 结果
     */
    @Override
    public int insertBaseCategory(BaseCategory baseCategory) {
        if (StringUtils.isNotNull(baseCategoryMapper.selectBaseCategoryById(baseCategory.getBaseCategoryId()))) {
            //已存在
            return 0;
        }
        if (baseCategory.getBaseCategoryParentId() == null || baseCategory.getBaseCategoryParentId() == "") {
            //无父级产品类别
            return baseCategoryMapper.insertBaseCategory(baseCategory);
        }
        //有父级产品类别
        BaseCategory info = baseCategoryMapper.selectBaseCategoryById(baseCategory.getBaseCategoryParentId());
        baseCategory.setAncestors(info.getAncestors() + "," + baseCategory.getBaseCategoryParentId());
        return baseCategoryMapper.insertBaseCategory(baseCategory);
    }

    /**
     * 修改产品类别数据
     *
     * @param baseCategory 产品类别信息
     * @return 结果
     */
    @Override
    public int updateBaseCategory(BaseCategory baseCategory) {
        if (!StringUtils.isNotNull(baseCategoryMapper.selectBaseCategoryById(baseCategory.getBaseCategoryId()))) {
            //不存在
            return 0;
        }
        //新的父级类别
        BaseCategory newParentBaseCategory = baseCategoryMapper.selectBaseCategoryById(baseCategory.getBaseCategoryParentId());
        //要更新的类别的旧属性
        BaseCategory oldBaseCategory = baseCategoryMapper.selectBaseCategoryById(baseCategory.getBaseCategoryId());
        if (StringUtils.isNotNull(newParentBaseCategory))//存在新的父级类别
        {
            //新的祖级编号
            String newAncestors = newParentBaseCategory.getAncestors() + "," + newParentBaseCategory.getBaseCategoryId();
            //旧的祖级编号
            String oldAncestors = oldBaseCategory.getAncestors();
            baseCategory.setAncestors(newAncestors);//更新祖级编号
            updateBaseCategoryChildren(baseCategory.getBaseCategoryId(), newAncestors, oldAncestors);
        }

        return baseCategoryMapper.updateBaseCategory(baseCategory);
    }

    /**
     * 修改子级类别关系
     * @param baseCategoryId 被修改的类别ID
     * @param newAncestors 新的父ID集合
     * @param oldAncestors 旧的父ID集合
     */
    public void updateBaseCategoryChildren(String baseCategoryId, String newAncestors, String oldAncestors)
    {
        List<BaseCategory> children = baseCategoryMapper.selectChildrenBaseCategoryById(baseCategoryId);
        for (BaseCategory child : children)
        {
            //更新子类别的祖级编号
            child.setAncestors(child.getAncestors().replace(oldAncestors, newAncestors));
        }
        if (children.size() > 0)
        {
            baseCategoryMapper.updateBaseCategoryChildren(children);
        }
    }

    /**
     * 删除功能
     * 更新对应产品类别删除标志
     *
     * @param baseCategory 产品类别信息
     * @return
     */
    @Override
    public int updateBaseCategoryDeleteFlag(BaseCategory baseCategory) {
        return baseCategoryMapper.updateBaseCategoryDeleteFlag(baseCategory);
    }


    /**
     * 构建前端所需要下拉树结构
     * 后端处理形成树结构情况下
     * @param baseCategories 产品类别列表
     * @return 下拉树结构列表
     */
    @Override
    public List<TreeSelect> buildBaseCategoryTreeSelect(List<BaseCategory> baseCategories) {
        List<BaseCategory> deptTrees = buildBaseCategoryTree(baseCategories);
        return deptTrees.stream().map(TreeSelect::new).collect(Collectors.toList());
    }

    /**
     * 构建前端所需要树结构
     *
     * @param baseCategorys 产品类别列表
     * @return 树结构列表
     */
    @Override
    public List<BaseCategory> buildBaseCategoryTree(List<BaseCategory> baseCategorys) {
        List<BaseCategory> returnList = new ArrayList<BaseCategory>();
        List<String> tempList = new ArrayList<String>();
        for (BaseCategory baseCategory : baseCategorys) {
            tempList.add(baseCategory.getBaseCategoryParentId());
        }
        for (Iterator<BaseCategory> iterator = baseCategorys.iterator(); iterator.hasNext(); ) {
            BaseCategory baseCategory = (BaseCategory) iterator.next();
            // 如果是顶级节点, 遍历该父节点的所有子节点
            if (!tempList.contains(baseCategory.getBaseCategoryParentId())) {
                recursionFn(baseCategorys, baseCategory);
                returnList.add(baseCategory);
            }
        }
        if (returnList.isEmpty()) {
            returnList = baseCategorys;
        }
        return returnList;
    }


    /**
     * 递归列表
     */
    private void recursionFn(List<BaseCategory> list, BaseCategory t) {
        // 得到子节点列表
        List<BaseCategory> childList = getChildList(list, t);
        t.setChildren(childList);
        for (BaseCategory tChild : childList) {
            if (hasChild(list, tChild)) {
                recursionFn(list, tChild);
            }
        }
    }

    /**
     * 得到子节点列表
     */
    private List<BaseCategory> getChildList(List<BaseCategory> list, BaseCategory t) {
        List<BaseCategory> tlist = new ArrayList<BaseCategory>();
        Iterator<BaseCategory> it = list.iterator();
        while (it.hasNext()) {
            BaseCategory n = (BaseCategory) it.next();
            if (StringUtils.isNotNull(n.getBaseCategoryParentId()) && n.getBaseCategoryParentId().equals(t.getBaseCategoryId())) {
                tlist.add(n);
            }
        }
        return tlist;
    }

    /**
     * 判断是否有子节点
     */
    private boolean hasChild(List<BaseCategory> list, BaseCategory t) {
        return getChildList(list, t).size() > 0 ? true : false;
    }
}
